package o;

import android.content.Context;
import android.content.res.Resources;
import o.ewm.d;
import o.ewm.f;

public final class eib {
    private static int ʻ;
    private static int ʻॱ;
    private static int ʼ;
    private static int ʼॱ;
    private static int ʽ;
    private static int ʽॱ;
    private static int ʾ;
    private static int ʿ;
    private static int ˈ;
    private static int ˉ;
    private static int ˊ;
    private static int ˊˊ;
    private static int ˊˋ;
    private static int ˊॱ;
    private static boolean ˊᐝ;
    private static int ˋ;
    private static int ˋˊ;
    private static int ˋˋ;
    private static int ˋॱ;
    private static int ˋᐝ;
    private static int ˌ;
    private static int ˍ;
    private static int ˎ;
    private static int ˎˎ;
    private static int ˏ;
    private static int ˏˎ;
    private static int ˏॱ;
    private static int ͺ;
    private static int ͺॱ;
    private static int ॱ;
    private static int ॱˊ;
    private static int ॱˋ;
    private static int ॱˎ;
    private static int ॱॱ;
    private static int ॱᐝ;
    private static int ᐝ;
    private static int ᐝॱ;

    public static int ॱ() {
        return ॱˋ;
    }

    public static void ˎ(int i) {
        ॱˋ = i;
    }

    public static int ˎ() {
        return ॱᐝ;
    }

    public static void ˊ(int i) {
        ॱᐝ = i;
    }

    public static void ॱ(Context context) {
        ˊ(context);
        ˎ(context);
        chc.ˎ(context);
    }

    private static void ˊ(Context context) {
        Resources ˊ = chf.ˊ(context);
        ʼ(azb.ˊ(context));
        ʽ(azb.ˏ(context));
        ˋ(ˊ.getDimensionPixelSize(d.ˊॱ));
        ᐝ(ˊ.getDimensionPixelSize(d.ॱˋ));
        ˏ(ˊ.getDimensionPixelSize(d.ˏॱ));
        ॱ(ˊ.getDimensionPixelSize(d.ˊॱ));
    }

    private static void ˎ(Context context) {
        Resources ˊ = chf.ˊ(context);
        ˎ(azb.ˊ(context));
        ˊ((int) ˊ.getDimension(d.ˊˊ));
        ᐝॱ(2);
        ˏॱ(ˊ.getInteger(f.ᐝ));
        ॱˎ(ˊ.getInteger(f.ʻ));
        ॱᐝ(1);
        ʻॱ(ˊ.getInteger(f.ˋ));
        ॱˋ(ˊ.getInteger(f.ˏ));
        ʿ(ˊ.getInteger(f.ʼ));
        ˈ(ˊ.getInteger(f.ॱॱ));
        ˋˊ(ˊ.getInteger(f.ˊ));
        ʼॱ((int) ˊ.getDimension(d.ˉ));
        ˊᐝ((int) ˊ.getDimension(d.ꜞ));
        ˉ((int) ˊ.getDimension(d.ㆍ));
        ʾ(ˊ.getInteger(f.ˎ));
        ʽॱ(ˊ.getInteger(f.ॱ));
        ˍ(1);
        ˊˊ = ˊ.getConfiguration().orientation;
        if (epr.ˎ().ॱॱ()) {
            ˎˎ();
        } else {
            ˌ();
        }
    }

    private static void ˌ() {
        ˊˋ(1);
        ˋˋ(3);
        ˊˊ(1);
        if (2 == ˊˊ || cdn.ॱॱ()) {
            ˍ();
        } else {
            ˋˋ();
        }
    }

    private static void ˋˋ() {
        ˋᐝ(2);
        ˋॱ(2);
        ॱˊ(2);
        ʻ(2);
        ˊॱ(1);
        ˌ(1);
        ॱॱ(1);
        ˎˎ(1);
        ͺ(1);
        ˍ(1);
        ˏ(true);
    }

    private static void ˍ() {
        ˋᐝ(4);
        ˋॱ(3);
        ॱˊ(3);
        ʻ(3);
        ˊॱ(2);
        ˌ(2);
        ॱॱ(2);
        ˎˎ(2);
        ͺ(2);
        ˍ(2);
        ˏ(false);
    }

    private static void ˎˎ() {
        if (2 == ˊˊ) {
            ˑ();
        } else {
            ˋᐝ();
        }
    }

    private static void ˋᐝ() {
        ˊˋ(1);
        ˋˋ(3);
        ˊˊ(1);
        ˋᐝ(4);
        ˋॱ(2);
        ॱˊ(2);
        ʻ(2);
        ˊॱ(2);
        ˌ(1);
        ॱॱ(2);
        ˎˎ(2);
        ͺ(2);
        ˍ(2);
        ˏ(false);
    }

    private static void ˑ() {
        ॱˎ(2);
        ˋˊ(2);
        ˈ(1);
        ˊˋ(2);
        ˋˋ(2);
        ˊˊ(2);
        ˋᐝ(6);
        ˋॱ(3);
        ॱˊ(3);
        ʻ(3);
        ˊॱ(3);
        ˌ(2);
        ॱॱ(3);
        ˎˎ(3);
        ͺ(3);
        ˍ(2);
        ˏ(false);
    }

    public static int ˋ() {
        return ˏˎ;
    }

    public static void ॱ(int i) {
        ˏˎ = i;
    }

    public static int ˏ() {
        return ˍ;
    }

    public static void ˏ(int i) {
        ˍ = i;
    }

    public static int ˊ() {
        return ˌ;
    }

    public static void ˋ(int i) {
        ˌ = i;
    }

    public static int ᐝ() {
        return ˎˎ;
    }

    public static void ᐝ(int i) {
        ˎˎ = i;
    }

    public static int ʽ() {
        return ˋˋ;
    }

    public static void ʽ(int i) {
        ˋˋ = i;
    }

    public static int ॱॱ() {
        return ˋᐝ;
    }

    public static void ʼ(int i) {
        ˋᐝ = i;
    }

    public static int ʼ() {
        return ˈ;
    }

    public static void ʻ(int i) {
        ˈ = i;
    }

    public static int ʻ() {
        return ˉ;
    }

    public static int ˋॱ() {
        return ˊˋ;
    }

    public static void ॱॱ(int i) {
        ˉ = i;
    }

    public static void ͺ(int i) {
        ˊˋ = i;
    }

    public static int ॱˊ() {
        return ʿ;
    }

    public static void ॱˊ(int i) {
        ʿ = i;
    }

    public static int ˏॱ() {
        return ʽॱ;
    }

    public static void ˋॱ(int i) {
        ʽॱ = i;
    }

    public static int ˊॱ() {
        return ʾ;
    }

    public static void ˊॱ(int i) {
        ʾ = i;
    }

    public static void ˏॱ(int i) {
        ˎ = i;
    }

    public static int ͺ() {
        return ˏ;
    }

    public static void ॱᐝ(int i) {
        ˏ = i;
    }

    public static int ॱˎ() {
        return ˋ;
    }

    public static void ॱˎ(int i) {
        ˋ = i;
    }

    public static int ॱˋ() {
        return ˊ;
    }

    public static void ᐝॱ(int i) {
        ˊ = i;
    }

    public static int ʻॱ() {
        return ॱ;
    }

    public static void ʻॱ(int i) {
        ॱ = i;
    }

    public static void ॱˋ(int i) {
        ᐝ = i;
    }

    public static void ʿ(int i) {
        ॱॱ = i;
    }

    public static int ॱᐝ() {
        return ʼ;
    }

    public static void ˈ(int i) {
        ʼ = i;
    }

    public static void ʽॱ(int i) {
        ʻ = i;
    }

    public static void ʾ(int i) {
        ʽ = i;
    }

    public static int ᐝॱ() {
        return ˏॱ;
    }

    public static void ʼॱ(int i) {
        ˏॱ = i;
    }

    public static int ʼॱ() {
        return ˋॱ;
    }

    public static void ˊᐝ(int i) {
        ˋॱ = i;
    }

    public static void ˉ(int i) {
        ˊॱ = i;
    }

    public static int ʾ() {
        return ˊˊ;
    }

    public static void ˋˊ(int i) {
        ͺ = i;
    }

    public static int ˈ() {
        return ॱˊ;
    }

    public static void ˊˋ(int i) {
        ॱˊ = i;
    }

    public static int ʿ() {
        return ॱˎ;
    }

    public static void ˊˊ(int i) {
        ॱˎ = i;
    }

    public static int ʽॱ() {
        return ʻॱ;
    }

    public static void ˋˋ(int i) {
        ʻॱ = i;
    }

    public static int ˉ() {
        return ᐝॱ;
    }

    public static void ˋᐝ(int i) {
        ᐝॱ = i;
    }

    public static int ˊˊ() {
        return ʼॱ;
    }

    public static void ˌ(int i) {
        ʼॱ = i;
    }

    public static int ˊᐝ() {
        return ˋˊ;
    }

    public static void ˎˎ(int i) {
        ˋˊ = i;
    }

    public static int ˋˊ() {
        return ͺॱ;
    }

    public static void ˍ(int i) {
        ͺॱ = i;
    }

    public static boolean ˊˋ() {
        return ˊᐝ;
    }

    public static void ˏ(boolean z) {
        ˊᐝ = z;
    }
}
